package com.byron.media.server.handlers;

import com.byron.media.server.config.MediaServerConfig;
import com.byron.media.server.model.MediaData;
import com.byron.media.server.model.ProxyMediaData;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.atomic.AtomicLong;

@Slf4j
//@ChannelHandler.Sharable
public class MediaServerHandler extends ChannelInboundHandlerAdapter {

    private SessionContainer sessionContainer;

    private MediaServerConfig config;        // 本机是否为proxyServer

    private AtomicLong seq = new AtomicLong(1);

    public MediaServerHandler(SessionContainer sessionContainer, MediaServerConfig config) {
        this.sessionContainer = sessionContainer;
        this.config = config;
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
//        MediaSession session = ctx.pipeline().get(MediaSession.class);
//        sessionContainer.addToGroup(session.session);

    }

    @Override
    public void channelRegistered(ChannelHandlerContext ctx) throws Exception {
        super.channelRegistered(ctx);
    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        super.channelInactive(ctx);
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        if(msg.getClass() ==  MediaData.class){
            MediaSession session = ctx.pipeline().get(MediaSession.class);
            if(session.isActive() && session.isSender()){
                MediaData mediaData = (MediaData)msg;

                // 分发的时候，设置包名
                // TODO 如果发送端掉线，包名会重置
                mediaData.setSeq(seq.getAndIncrement());
                sessionContainer.sendToGroup(session.getGroupName(), mediaData);

                // 如果是代理服务器，需要往上发送
                if(config.isProxyServer()){
                    sessionContainer.sendToMainServer(new ProxyMediaData(session.getGroupName(), mediaData));
                }

                // 如果是来自无线的终端，而且需要组播则 发送组播
                if(config.isBroadcastRtp() && mediaData.isFromWireless()){
                    sessionContainer.broadcastAsRtp(session.getGroupName(), mediaData);
                }
            }

        // 作为主服务器时，会收到终端发来的代理数据
        } else if(msg.getClass() == ProxyMediaData.class){
            ProxyMediaData proxyData = (ProxyMediaData)msg;
            sessionContainer.sendToGroup(proxyData.getGroupName(), proxyData.getMediaData());

            // 本服务器是否为代理，如果是则继续向上发送代理
            // TODO 高级算法（判断主服务器是否需要该流媒体数据）
//            sessionContainer.sendToMainServer(proxyData);

            if(config.isBroadcastRtp()){
                sessionContainer.sendToMainServer(proxyData);
            }

            // 如果是来自无线的终端，而且需要组播则 发送组播
            if(config.isBroadcastRtp() && proxyData.getMediaData().isFromWireless()){
                sessionContainer.broadcastAsRtp(proxyData.getGroupName(), proxyData.getMediaData());
            }
        }
        ctx.fireChannelReadComplete();
    }
}
